﻿using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Web.Mvc;
using System.Xml.Serialization;
using ABC.Business.finist.mycalc;
using ABC.Domain.Entities;
using ABC.Domain.Json;
using ABC.Domain.Serialization;
using Castle.Core.Logging;
using HtmlAgilityPack;
using RosService.Data;

namespace ABC.Business.Models
{
    public class RbsCalcModel
    {
        private KaskoServiceService Wpf;
        private readonly string token;
        private readonly RosModel rosModel;
        private readonly FinanceModel financeModel;
        private readonly ILogger logger;

        public RbsCalcModel(RosModel rosModel, FinanceModel financeModel, ILogger logger)
        {
            this.rosModel = rosModel;
            this.financeModel = financeModel;
            this.logger = logger;
            Wpf = new KaskoServiceService();
            try
            {
                token = Wpf.logon("rit", "dF836066dc");
            }
            catch (Exception ex)
            {
                logger.Error(ex.Message, ex);
            }
        }


        public List<SelectListItem> GetDictionary(string dictionary)
        {
            var result = new List<SelectListItem>();
            try
            {
                Wpf.getDictionaryValues(token, dictionary).ToList().ForEach(m => result.Add(new SelectListItem { Text = m, Value = m }));
            }
            catch (Exception ex)
            {
                logger.Error(ex.Message, ex);
            }
            return result;
        }

        public List<SelectListItem> GetDictionaryByValue(string dictionary, string value)
        {
            var result = new List<SelectListItem>();
            try
            {
                Wpf.getDictionaryValuesByValue(token, dictionary, value).ToList().ForEach(m => result.Add(new SelectListItem { Text = m, Value = m }));
            }
            catch (Exception ex)
            {
                logger.Error(ex.Message, ex);
            }
            return result;
        }
        public string[] GetArrayByValue(string dictionary, string value)
        {
            return Wpf.getDictionaryValuesByValue(token, dictionary, value);
        }
        public attribute[] GetAttributes()
        {
            return Wpf.getAllAttributes(token);
        }
        public shortResult[] CalcKasko(Dictionary<string, string> attrs)
        {
            return Wpf.calcCascoAttributeData(token, attrs.Select(x => new attributeRequest { name = x.Key, value = x.Value }).ToArray());
        }
        // пока не используется
        public string GetAvgPrice(string mark, string model, int year)
        {
            return Wpf.getAvgPrice(token, mark, model, year).ToString("N2");
        }

        public string SaveSerializeKaskoExpress(string id, Dictionary<string, string> attrs, List<KaskoResult> results)
        {
            var obj = new KaskoExpress
                          {
                              UniqueNumber = attrs["uniquenumber"],
                              CarManufacture = attrs["Марка"],
                              CarModel = attrs["Модель"],
                              Region = attrs["Регион"],
                              Release = attrs["Год выпуска"],
                              TypeDrivers = attrs["Допущенные водители"],
                              Insurant = attrs["Страхователь"],
                              ControlWheel = attrs["Руль"],
                              Guaranty = attrs["Гарантия"],
                              IsNewCar = attrs["Новое"],
                              FourWheelDrive = attrs["Полный привод"],
                              Currency = attrs["Валюта расчета"],
                              Maxpath = attrs["Предельный пробег"],
                              BeginningOfOperation = attrs["Дата начала эксплуатации"],
                              DateOfCalculation = attrs["Дата расчета"],
                              Power = attrs["Мощность"],
                              Credit = attrs["Банк"],
                              Cost = attrs["Стоимость ТС"],
                              Signaling = attrs["ЭПС"],
                              Immo = attrs["Иммобилайзер"],
                              Path = attrs["Пробег"],
                              UnitPath = attrs["Единицы пробега"]
                          };
            if (obj.TypeDrivers == "Ограниченное количество")
            {
                if (attrs.Keys.Contains("Пол водителя"))
                {
                    var driver = new Driver
                    {
                        Sex = attrs["Пол водителя"],
                        Age = attrs["Возраст водителя"],
                        Experience = attrs["Стаж водителя"],
                        Married = attrs["Наличие брака водителя"],
                        Children = attrs["Количество детей водителя"]
                    };
                    obj.Drivers.Add(driver);
                }
                var i = 2;
                while (attrs.Keys.Contains("Пол водителя " + i))
                {
                    var driver = new Driver
                    {
                        Sex = attrs["Пол водителя " + i],
                        Age = attrs["Возраст водителя " + i],
                        Experience = attrs["Стаж водителя " + i],
                        Married = attrs["Наличие брака водителя " + i],
                        Children = attrs["Количество детей водителя " + i]
                    };
                    i++;
                    obj.Drivers.Add(driver);
                }

            }
            if (obj.TypeDrivers == "Неограниченное количество")
            {
                obj.MinAge = attrs["Минимальный возраст"];
                obj.MinPeriod = attrs["Минимальный стаж"];
            }
            obj.KaskoResults = results;
            var serializer = new XmlSerializer(typeof(KaskoExpress));
            var sb = new StringBuilder();
            var w = new StringWriter(sb, System.Globalization.CultureInfo.InvariantCulture);
            serializer.Serialize(w, obj);
            var values = new Dictionary<string, object>
                             {
                                 {"НазваниеОбъекта", "Расчёт, " + obj.CarManufacture + " " + obj.CarModel + ", " + obj.Release},
                                 {"ТипРасчета", "КАСКОЭкспресс"},
                                 {"Xml", sb.ToString()}
                             };
            return rosModel.AddEntity(id, "РасчётСтраховки", values).ToString();
        }
        public string SaveSerializeKasko(string id, Dictionary<string, string> attrs, List<KaskoResult> results)
        {
            var obj = new Kasko
                          {
                              UniqueNumber = attrs["uniquenumber"],
                              CarManufacture = attrs["Марка"],
                              CarModel = attrs["Модель"],
                              Region = attrs["Регион"],
                              Release = attrs["Год выпуска"],
                              TypeDrivers = attrs["Допущенные водители"],
                              Insurant = attrs["Страхователь"],
                              ControlWheel = attrs["Руль"],
                              Guaranty = attrs["Гарантия"],
                              IsNewCar = attrs["Новое"],
                              Currency = attrs["Валюта расчета"],
                              Maxpath = attrs["Предельный пробег"],
                              BeginningOfOperation = attrs["Дата начала эксплуатации"],
                              DateOfCalculation = attrs["Дата расчета"],
                              Power = attrs["Мощность"],
                              Credit = attrs["Кредит"],
                              Cost = attrs["Стоимость ТС"],
                              Signaling = attrs["ЭПС"],
                              Immo = attrs["Иммобилайзер"],
                              Autostart = attrs["ЭПС с автозапуском"],
                              InsurancePeriod = attrs["Срок страхования"],
                              Mpu = attrs["МПУ"],
                              Payment = attrs["Оплата"],
                              QuantityTs = attrs["Количество ТС"],
                              Siganticreep = attrs["Противоугонный комплекс"],
                              Siglabel = attrs["Метка"],
                              FranshizaInRub = attrs["Франшиза в рублях"],
                              FranshizaInProc = attrs["Франшиза в процентах"],
                              Compensation = attrs["Форма возмещения"],
                              StorageCondition = attrs["Условия хранения"],
                              Transition = attrs["Переход"],
                              Sigantidamping = attrs["ОПС"],
                              //не участвовали в расчете
                              OwnerTs = attrs["Собственник ТС"],
                              CategoryTs = attrs["Категория ТС"],
                              Risk = attrs["Риск"],
                              Limit = attrs["Лимит ответственности"],
                              Pts = attrs["Дата выдачи ПТС"],
                              Path = attrs["Пробег"],
                              UnitPath = attrs["Единицы пробега"],
                              Engine = attrs["Объем двигателя"],
                              UnitMaxPath = attrs["Единицы предельного пробега"],
                              Landing = attrs["Количество мест"],
                              MaxMass = attrs["Масса"],
                              Mass = attrs["Грузоподъемность"],
                              SignalingAdd = attrs["Дополнительная ЭПС"],
                          };

            if (obj.TypeDrivers == "Ограниченное количество")
            {
                if (attrs.Keys.Contains("Пол водителя"))
                {
                    var driver = new Driver
                    {
                        Sex = attrs["Пол водителя"],
                        Age = attrs["Возраст водителя"],
                        Experience = attrs["Стаж водителя"],
                        Married = attrs["Наличие брака водителя"],
                        Children = attrs["Количество детей водителя"]
                    };
                    obj.Drivers.Add(driver);
                }
                var i = 2;
                while (attrs.Keys.Contains("Пол водителя " + i))
                {
                    var driver = new Driver
                    {
                        Sex = attrs["Пол водителя " + i],
                        Age = attrs["Возраст водителя " + i],
                        Experience = attrs["Стаж водителя " + i],
                        Married = attrs["Наличие брака водителя " + i],
                        Children = attrs["Количество детей водителя " + i]
                    };
                    i++;
                    obj.Drivers.Add(driver);
                }

            }
            if (obj.TypeDrivers == "Неограниченное количество")
            {
                obj.MinAge = attrs["Минимальный возраст"];
                obj.MinPeriod = attrs["Минимальный стаж"];
            }

            obj.KaskoResults = results;
            var serializer = new XmlSerializer(typeof(Kasko));
            var sb = new StringBuilder();
            var w = new StringWriter(sb, System.Globalization.CultureInfo.InvariantCulture);
            serializer.Serialize(w, obj);
            var values = new Dictionary<string, object>
                             {
                                 {"НазваниеОбъекта", "Расчёт, " + obj.CarManufacture + " " + obj.CarModel + ", " + obj.Release},
                                 {"ТипРасчета", "КАСКОПолный"},
                                 {"Xml", sb.ToString()},
                                 {"СохраненРасчет", false}
                             };
            return rosModel.AddEntity(id, "РасчётСтраховки", values).ToString();
        }
        public Kasko GetCalculationKasko(string id)
        {
            var serializer = new XmlSerializer(typeof(Kasko));
            var xml = rosModel.GetEntityValue<string>(id, "Xml");
            var stream = new StringReader(xml);
            var result = (Kasko)serializer.Deserialize(stream);
            return result;
        }

        public Osago GetCalculationOsago(string id)
        {
            var serializer = new XmlSerializer(typeof(Osago));
            var xml = rosModel.GetEntityValue<string>(id, "Xml");
            var stream = new StringReader(xml);
            var result = (Osago)serializer.Deserialize(stream);
            return result;
        }

        public List<EditCalc> GetAllConfirmedCalculationsKasko(string ownerId)
        {
            var calculations = GetAllSaveCalculationsKasko(ownerId);
            foreach (var calculation in calculations)
            {
                var confirmedCalcs = rosModel.GetEntities("ПодтверждениеРасчета", calculation.Id,
                                                          new Dictionary<string, Query.НаправлениеСортировки>
                                                              {
                                                                  {
                                                                      "ДатаСозданияОбъекта",
                                                                      Query.НаправлениеСортировки.Desc
                                                                  }
                                                              }, new Dictionary<string, object>
                                                                     {
                                                                         {"ФлагРасчетПодтвержден", true}
                                                                     }, new[]
                                                                            {
                                                                                "Тариф","ПремияПоПолису", "НазваниеОбъекта","ВеличинаПервогоВзносаРуб"
                                                                            }).AsEnumerable();
                foreach (var calc in confirmedCalcs)
                {
                    var confirmedCalc = new ConfirmedCalc();
                    confirmedCalc.CompanyName = calc["НазваниеОбъекта"].ToString();
                    confirmedCalc.Id = calc["id_node"].ToString();
                    confirmedCalc.PremiumPolicy = calc["ПремияПоПолису"].ToString();
                    confirmedCalc.ConfirmationDate = DateTime.Parse(calc["ДатаСозданияОбъекта"].ToString());
                    confirmedCalc.FeeRub = Double.Parse(calc["ВеличинаПервогоВзносаРуб"].ToString());
                    double rate;
                    confirmedCalc.Rate = Double.TryParse(calc["Тариф"].ToString(), out rate) ? rate : 0;
                    calculation.ConfirmedCalcs.Add(confirmedCalc);
                }
            }
            while (true)
            {
                if (calculations.Any(x => x.ConfirmedCalcs.Count == 0))
                {
                    calculations.Remove(calculations.FirstOrDefault(x => x.ConfirmedCalcs.Count == 0));
                }
                else
                {
                    break;
                }
            }
            return calculations;
        }

        public List<EditCalc> GetAllConfirmedCalculationsOsago(string ownerId)
        {
            var calculations = GetAllSaveCalculationsOsago(ownerId);
            foreach (var calculation in calculations)
            {
                var confirmedCalcs = rosModel.GetEntities("ПодтвержденныйРасчетОсаго", calculation.Id,
                                                          new Dictionary<string, Query.НаправлениеСортировки>
                                                              {
                                                                  {
                                                                      "ДатаСозданияОбъекта",
                                                                      Query.НаправлениеСортировки.Desc
                                                                  }
                                                              }, new Dictionary<string, object>(), new[]
                                                                            {
                                                                               "НазваниеОбъекта"
                                                                            }).AsEnumerable();
                foreach (var calc in confirmedCalcs)
                {
                    var confirmedCalc = new ConfirmedCalc();
                    confirmedCalc.CompanyName = calc["НазваниеОбъекта"].ToString();
                    confirmedCalc.Id = calc["id_node"].ToString();
                    calculation.ConfirmedCalcs.Add(confirmedCalc);
                }
            }
            while (true)
            {
                if (calculations.Any(x => x.ConfirmedCalcs.Count == 0))
                {
                    calculations.Remove(calculations.FirstOrDefault(x => x.ConfirmedCalcs.Count == 0));
                }
                else
                {
                    break;
                }
            }
            return calculations;
        }

        public List<EditCalc> SplitByPages(List<EditCalc> calculations, int begin, int pagesize)
        {
            var i = 0;
            var currentCount = 0;
            while (i < calculations.Count)
            {
                if (begin == 0)
                {
                    break;
                }
                currentCount = currentCount + calculations[i].ConfirmedCalcs.Count;
                if (currentCount >= begin)
                {
                    calculations[i].ConfirmedCalcs.RemoveRange(0, begin - currentCount + calculations[i].ConfirmedCalcs.Count);
                    if (calculations[i].ConfirmedCalcs.Count == 0)
                    {
                        calculations.RemoveAt(i);
                    }
                    break;
                }
                calculations.RemoveAt(i);
            }
            i = 0;
            currentCount = 0;
            while (i < calculations.Count)
            {
                currentCount = currentCount + calculations[i].ConfirmedCalcs.Count;
                if (currentCount >= pagesize)
                {
                    var difference = currentCount - pagesize;
                    calculations[i].ConfirmedCalcs.RemoveRange(calculations[i].ConfirmedCalcs.Count - difference, difference);
                    if (calculations.Count > i + 1)
                    {
                        calculations.RemoveRange(i + 1, calculations.Count - i - 1);
                    }
                    break;
                }
                i++;
            }
            return calculations;
        }

        public List<EditCalc> GetAllSaveCalculationsKasko(string ownerId)
        {
            var calculations = ConvertKasko(rosModel.GetEntities("РасчётСтраховки", ownerId, new Dictionary<string, Query.НаправлениеСортировки>
                                                                                                 {
                                                                                                     { "ДатаСозданияОбъекта", Query.НаправлениеСортировки.Desc }
                                                                                                 },
                                                                                            new Dictionary<string, object>
                                                                                          {
                                                                                              {"ТипРасчета", "КАСКОПолный"},
                                                                                              {"СохраненРасчет", true}
                                                                                          }, new[] { "НазваниеОбъекта", "ДатаСозданияОбъекта" }).AsEnumerable().ToList());

            return calculations;
        }

        public List<EditCalc> GetAllSaveCalculationsOsago(string ownerId)
        {
            var calculations = ConvertOsago(rosModel.GetEntities("РасчётСтраховки", ownerId, new Dictionary<string, Query.НаправлениеСортировки>
                                                                                                 {
                                                                                                     { "ДатаСозданияОбъекта", Query.НаправлениеСортировки.Desc }
                                                                                                 },
                                                                                            new Dictionary<string, object>
                                                                                          {
                                                                                              {"ТипРасчета", "ОСАГО"},
                                                                                              {"СохраненРасчет", true}
                                                                                          }, new[] { "НазваниеОбъекта", "ДатаСозданияОбъекта", "СсылкаНаОбъект" }).AsEnumerable().ToList());

            return calculations;
        }

        private List<EditCalc> ConvertOsago(IEnumerable<DataRow> calculations)
        {
            var serializer = new XmlSerializer(typeof(Osago));
            var result = new List<EditCalc>();
            foreach (var calc in calculations)
            {
                var xml = rosModel.GetEntityValue<string>(calc["id_node"].ToString(), "Xml");
                var stream = new StringReader(xml);
                var osago = (Osago)serializer.Deserialize(stream);
                var editCalc = new EditCalc
                {
                    Id = calc["id_node"].ToString(),
                    UniqueNumber = osago.UniqueNumber,
                    CalculationDate = DateTime.Parse(calc["ДатаСозданияОбъекта"].ToString()),
                    ObjectId = calc["СсылкаНаОбъект"].ToString(),
                    ObjectName = calc["СсылкаНаОбъект.НазваниеОбъекта"].ToString(),
                    TypeCalculation = "КАСКО",
                    PremiumPolicy = osago.Result.InsurancePremium.ToString("N2"),
                    WhoConfirmed = ""
                };
                result.Add(editCalc);
            }
            return result;
        }

        public List<EditCalc> GetAllSaveCalculations(string ownerId)
        {
            var calculations = rosModel.GetEntities("РасчётСтраховки", ownerId, new Dictionary<string, Query.НаправлениеСортировки>(),
                                                                                            new Dictionary<string, object>
                                                                                          {
                                                                                              {"СохраненРасчет", true}
                                                                                          }, new[] { "НазваниеОбъекта", "УникальныйНомер", "ДатаСозданияОбъекта", "ТипРасчета", "СсылкаНаОбъект", "СсылкаНаОбъект/Марка", "СсылкаНаОбъект/Модель", "СсылкаНаОбъект/ГодВыпуска" }).AsEnumerable();
            var result = new List<EditCalc>();
            result.AddRange(ConvertKasko(calculations.Where(x => x["ТипРасчета"].ToString().IndexOf("КАСКО", StringComparison.OrdinalIgnoreCase) > -1)));
            foreach (var calc in calculations)
            {
                if (calc["ТипРасчета"].ToString().IndexOf("ОСАГО", StringComparison.OrdinalIgnoreCase) > -1)
                {
                    var editCalc = new EditCalc
                    {
                        Id = calc["id_node"].ToString(),
                        UniqueNumber = calc["УникальныйНомер"].ToString(),
                        CalculationDate = DateTime.Parse(calc["ДатаСозданияОбъекта"].ToString()),
                        CarManufacture = calc["СсылкаНаОбъект/Марка"].ToString(),
                        CarModel = calc["СсылкаНаОбъект/Модель"].ToString(),
                        Release = calc["СсылкаНаОбъект/ГодВыпуска"].ToString(),
                        Risk = "ОСАГО",
                        TypeCalculation = "ОСАГО",
                        WhoConfirmed = ""
                    };
                    result.Add(editCalc);
                }
            }

            return result.OrderByDescending(x => x.CalculationDate).ToList();
        }

        public List<EditCalc> SortCalculations(string ownerId)
        {
            var calculations = GetAllSaveCalculations(ownerId);
            var result = new List<EditCalc>();
            var key = string.Empty;
            while (calculations.Count != 0)
            {
                result.Add(calculations[0]);
                key = calculations[0].CarManufacture + calculations[0].CarModel + calculations[0].Release;
                calculations.Remove(calculations[0]);
                while (true)
                {
                    if (calculations.Any(x => x.CarManufacture + x.CarModel + x.Release == key))
                    {
                        var calc = calculations.FirstOrDefault(x => x.CarManufacture + x.CarModel + x.Release == key);
                        result.Add(calc);
                        calculations.Remove(calc);
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return result;
        }

        private List<EditCalc> ConvertKasko(IEnumerable<DataRow> calculations, string filter = "")
        {
            var serializer = new XmlSerializer(typeof(Kasko));
            var result = new List<EditCalc>();
            foreach (var calc in calculations)
            {
                var xml = rosModel.GetEntityValue<string>(calc["id_node"].ToString(), "Xml");
                var stream = new StringReader(xml);
                var kasko = (Kasko)serializer.Deserialize(stream);

                if (!string.IsNullOrEmpty(filter))
                {
                    if (filter == string.Format("{0} {1}, {2}", kasko.CarManufacture, kasko.CarModel, kasko.Release).ToLower())
                    {
                        var editCalc = new EditCalc
                        {
                            Id = calc["id_node"].ToString(),
                            UniqueNumber = kasko.UniqueNumber,
                            CalculationDate = DateTime.Parse(calc["ДатаСозданияОбъекта"].ToString()),
                            CarManufacture = kasko.CarManufacture,
                            CarModel = kasko.CarModel,
                            Release = kasko.Release,
                            Risk = kasko.Risk,
                            TypeCalculation = "КАСКО",
                            WhoConfirmed = ""
                        };
                        result.Add(editCalc);
                    }
                }
                else
                {
                    var editCalc = new EditCalc
                    {
                        Id = calc["id_node"].ToString(),
                        UniqueNumber = kasko.UniqueNumber,
                        CalculationDate = DateTime.Parse(calc["ДатаСозданияОбъекта"].ToString()),
                        CarManufacture = kasko.CarManufacture,
                        CarModel = kasko.CarModel,
                        Release = kasko.Release,
                        Risk = kasko.Risk,
                        TypeCalculation = "КАСКО",
                        WhoConfirmed = ""
                    };
                    result.Add(editCalc);
                }

            }
            return result;
        }

        public List<EditCalc> GetCalculationsForObject(string userId, string objectId, string query)
        {
            var filters = new Dictionary<string, object> { { "ТипРасчета", "КАСКОПолный" } };
            if (!string.IsNullOrEmpty(query))
            {
                filters.Add("НазваниеОбъекта", query);
            }
            var calculations = ConvertKasko(rosModel.GetEntities(
                "[Типы=РасчётСтраховки;Колонки=(НазваниеОбъекта,ДатаСозданияОбъекта);Сортировки=(ДатаСозданияОбъекта,Desc);Места=(" +
                userId + ",1);Условия=(СохраненРасчет,true,Равно);]", filters));

            filters.Clear();
            //filters.Add("ТипРасчета", "ОСАГО");
            calculations.AddRange(rosModel.GetEntities("[Типы=РасчётСтраховки;Колонки=(НазваниеОбъекта,ДатаСозданияОбъекта,УникальныйНомер,СсылкаНаОбъект/Модель,СсылкаНаОбъект/ГодВыпуска,СсылкаНаОбъект/Марка);Сортировки=(ДатаСозданияОбъекта,Desc);Места=(" +
                userId + ",1);Условия=(СохраненРасчет,true,Равно);Условия=(СсылкаНаОбъект," + objectId + ",Равно);Условия=(ТипРасчета,ОСАГО,Соодержит);]", filters).Select(
                x => new EditCalc
                       {
                           Id = x["id_node"].ToString(),
                           UniqueNumber = x["УникальныйНомер"].ToString(),
                           CalculationDate = DateTime.Parse(x["ДатаСозданияОбъекта"].ToString()),
                           CarManufacture = x["СсылкаНаОбъект/Марка"].ToString(),
                           CarModel = x["СсылкаНаОбъект/Модель"].ToString(),
                           Release = x["СсылкаНаОбъект/ГодВыпуска"].ToString(),
                           Risk = "ОСАГО",
                           TypeCalculation = "ОСАГО",
                           WhoConfirmed = ""
                       }));
            return calculations.OrderByDescending(x => x.CalculationDate).ToList();
        }
        public Dictionary<string, string> GetCredits()
        {
            return
                rosModel.GetEntities(
                    "[Типы=Партнер;Колонки=(НазваниеОбъекта);Сортировки=(НазваниеОбъекта,Asc)];Места=(Партнеры,1)]", new Dictionary<string, object> { { "Вид", "Банк" } }).ToDictionary(
                        company => company["НазваниеОбъекта"].ToString(),
                        company => company["НазваниеОбъекта"].ToString());
        }
        public string GetAverageCost(string manufacture, string model, string release)
        {
            string url = @"http://auto.yandex.ru/avg-price.xml?rid=225" +
                         "&mark=" + manufacture.ToUpper() +
                         "&model=" + model.ToUpper() +
                         "&year=" + release;

            var request = (HttpWebRequest)WebRequest.Create(url);
            request.ContentType = "text/html";
            var response = request.GetResponse();
            var html = new HtmlDocument();
            html.Load(response.GetResponseStream(), Encoding.UTF8);
            var content = html.GetElementbyId("content");
            if (content != null)
            {
                foreach (var item in content.ChildNodes)
                {
                    var element = item.ChildNodes.Where(x => x.Attributes.Where(t => t.Value == "statplotter-header").Any()).FirstOrDefault();
                    if (element != null)
                    {
                        return element.InnerText.Replace("Средняя цена в прошлом месяце:", "");
                    }
                }
            }
            return "no";
        }

        public CalculationForConfirm GetCalculationForConfirm(string id)
        {
            var confirmTarif = rosModel.GetEntityById("ПодтверждениеРасчета", id, new Dictionary<string, object> { { "ТипПодтверждения", "Самостоятельно" } },
                                                new[]
                                                    {
                                                        "НазваниеОбъекта",
                                                        "СтраховаяСумма",
                                                        "Тариф",
                                                        "РасчетнаяПремия",
                                                        "ОфициальнаяСкидка",
                                                        "НеофициальнаяСкидка",
                                                        "ПремияПоПолису",
                                                        "ВеличинаПервогоВзноса",
                                                        "ВеличинаПервогоВзносаРуб",
                                                        "СтоимостьПолиса",
                                                        "ДатаЗагрузкиФайлаРасчета",
                                                        "СсылкаНаФайлРасчета"
                                                    });
            if (confirmTarif != null)
            {
                return new CalculationForConfirm
                           {
                               Id = id,
                               Name = confirmTarif["НазваниеОбъекта"].ToString(),
                               ConfirmType = confirmTarif["ТипПодтверждения"].ToString(),
                               CostPolicy = string.IsNullOrEmpty(confirmTarif["СтоимостьПолиса"].ToString()) ? "0" : confirmTarif["СтоимостьПолиса"].ToString(),
                               InsuredSum = string.IsNullOrEmpty(confirmTarif["СтраховаяСумма"].ToString()) ? "0" : Double.Parse(confirmTarif["СтраховаяСумма"].ToString()).ToString("N2"),
                               OfficialDiscount = string.IsNullOrEmpty(confirmTarif["ОфициальнаяСкидка"].ToString()) ? "0" : Double.Parse(confirmTarif["ОфициальнаяСкидка"].ToString()).ToString("N2"),
                               UnofficialDiscount = string.IsNullOrEmpty(confirmTarif["НеофициальнаяСкидка"].ToString()) ? "0" : Double.Parse(confirmTarif["НеофициальнаяСкидка"].ToString()).ToString("N2"),
                               CalculatedPremium = string.IsNullOrEmpty(confirmTarif["РасчетнаяПремия"].ToString()) ? "0" : confirmTarif["РасчетнаяПремия"].ToString(),
                               PremiumPolicy = string.IsNullOrEmpty(confirmTarif["ПремияПоПолису"].ToString()) ? "0" : confirmTarif["ПремияПоПолису"].ToString(),
                               Rate = string.IsNullOrEmpty(confirmTarif["Тариф"].ToString()) ? "0" : Double.Parse(confirmTarif["Тариф"].ToString()).ToString("N2"),
                               Fee = string.IsNullOrEmpty(confirmTarif["ВеличинаПервогоВзноса"].ToString()) ? "0" : confirmTarif["ВеличинаПервогоВзноса"].ToString(),
                               FeeRub = string.IsNullOrEmpty(confirmTarif["ВеличинаПервогоВзносаРуб"].ToString()) ? "0" : confirmTarif["ВеличинаПервогоВзносаРуб"].ToString(),
                               FileName = confirmTarif["СсылкаНаФайлРасчета.НазваниеОбъекта"].ToString(),
                               FileId = confirmTarif["СсылкаНаФайлРасчета"].ToString(),
                               DateUploadFile = confirmTarif.Field<DateTime?>("ДатаЗагрузкиФайлаРасчета") != null ? confirmTarif.Field<DateTime>("ДатаЗагрузкиФайлаРасчета").ToString("g") : ""
                           };

            }
            return new CalculationForConfirm();
        }

        public List<Company> GetInsuranceCompanies()
        {
            return rosModel.GetEntities(
                "[Типы=Партнер;Колонки=(НазваниеОбъекта);Сортировки=(НазваниеОбъекта,Asc);Места=(Партнеры,1);Условия=(Вид,Страховая компания,Соодержит);]",
                new Dictionary<string, object>()).Select(x => new Company { Id = x["id_node"].ToString(), Name = x["НазваниеОбъекта"].ToString() }).ToList();
        }

        public List<Company> GetCompaniesWithOsago()
        {
            var partners = rosModel.GetEntities(
                "[Типы=Партнер;Колонки=(НазваниеОбъекта);Сортировки=(НазваниеОбъекта,Asc);Места=(Партнеры,1);Условия=(Вид,Страховая компания,Соодержит);]",
                new Dictionary<string, object>());//Select(x => new Company { Id = x["id_node"].ToString(), Name = x["НазваниеОбъекта"].ToString() }).ToList();
            return (from partner in partners
                    where
                        financeModel.GetFinancialPolicy(partner["id_node"].ToString()).PolicyItems.Any(
                            x => !x.IsArchive && x.TypeOfInsuranceName == "ОСАГО")
                    select
                        new Company { Id = partner["id_node"].ToString(), Name = partner["НазваниеОбъекта"].ToString() }).
                ToList();
        }
    }
}